#!/bin/bash

# DevOps SmartBot 项目初始化脚本
set -e

echo "🚀 DevOps SmartBot 项目初始化脚本"
echo "=================================="

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# 日志函数
log_info() {
    echo -e "${BLUE}[INFO]${NC} $1"
}

log_success() {
    echo -e "${GREEN}[SUCCESS]${NC} $1"
}

log_warning() {
    echo -e "${YELLOW}[WARNING]${NC} $1"
}

log_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}

# 检查命令是否存在
check_command() {
    if ! command -v $1 &> /dev/null; then
        log_error "$1 命令未找到，请先安装 $1"
        exit 1
    fi
}

# 检查系统要求
check_requirements() {
    log_info "检查系统要求..."
    
    # 检查 Docker
    check_command "docker"
    log_success "Docker 已安装"
    
    # 检查 Docker Compose
    check_command "docker-compose"
    log_success "Docker Compose 已安装"
    
    # 检查 Node.js (可选，用于本地开发)
    if command -v node &> /dev/null; then
        NODE_VERSION=$(node --version)
        log_success "Node.js 已安装: $NODE_VERSION"
    else
        log_warning "Node.js 未安装，只能使用 Docker 方式运行"
    fi
    
    # 检查端口占用
    check_port() {
        if lsof -Pi :$1 -sTCP:LISTEN -t >/dev/null 2>&1; then
            log_warning "端口 $1 已被占用，可能会导致服务启动失败"
        fi
    }
    
    log_info "检查端口占用..."
    check_port 3000  # 前端
    check_port 8000  # 后端
    check_port 9090  # Prometheus
    check_port 9093  # Alertmanager
    check_port 3001  # Grafana
    check_port 27017 # MongoDB
    check_port 6379  # Redis
}

# 创建环境配置文件
create_env_files() {
    log_info "创建环境配置文件..."
    
    # 后端环境配置
    if [ ! -f "./backend/.env" ]; then
        log_info "创建后端环境配置文件..."
        cp ./backend/.env.example ./backend/.env
        
        # 生成随机 JWT 密钥
        JWT_SECRET=$(openssl rand -hex 32)
        sed -i.bak "s/your-super-secret-jwt-key-change-this-in-production/$JWT_SECRET/g" ./backend/.env
        rm ./backend/.env.bak 2>/dev/null || true
        
        log_success "后端环境配置文件已创建"
    else
        log_info "后端环境配置文件已存在"
    fi
    
    # 前端环境配置
    if [ ! -f "./frontend/.env" ]; then
        log_info "创建前端环境配置文件..."
        cat > ./frontend/.env << EOF
REACT_APP_API_URL=http://localhost:8000/api
REACT_APP_WS_URL=http://localhost:8000
REACT_APP_VERSION=1.0.0
EOF
        log_success "前端环境配置文件已创建"
    else
        log_info "前端环境配置文件已存在"
    fi
}

# 创建数据目录
create_directories() {
    log_info "创建必要的目录..."
    
    mkdir -p ./backend/logs
    mkdir -p ./backend/uploads
    mkdir -p ./monitoring/data
    mkdir -p ./scripts/backup
    
    log_success "目录创建完成"
}

# 创建 MongoDB 初始化脚本
create_mongo_init() {
    log_info "创建 MongoDB 初始化脚本..."
    
    cat > ./scripts/mongo-init.js << 'EOF'
// MongoDB 初始化脚本
db = db.getSiblingDB('devops-smart-bot');

// 创建应用用户
db.createUser({
  user: 'devops',
  pwd: 'devops123',
  roles: [
    {
      role: 'readWrite',
      db: 'devops-smart-bot'
    }
  ]
});

// 创建基础集合
db.createCollection('users');
db.createCollection('roles');
db.createCollection('permissions');
db.createCollection('alerts');
db.createCollection('tickets');
db.createCollection('knowledge');

// 插入默认角色
db.roles.insertMany([
  {
    _id: ObjectId(),
    name: 'admin',
    displayName: '系统管理员',
    description: '拥有系统所有权限',
    permissions: ['all'],
    isSystemRole: true,
    createdAt: new Date(),
    updatedAt: new Date()
  },
  {
    _id: ObjectId(),
    name: 'ops',
    displayName: '运维工程师',
    description: '负责告警和工单处理',
    permissions: ['alerts:read', 'alerts:update', 'tickets:read', 'tickets:create', 'tickets:update'],
    isSystemRole: true,
    createdAt: new Date(),
    updatedAt: new Date()
  },
  {
    _id: ObjectId(),
    name: 'developer',
    displayName: '开发工程师',
    description: '开发和技术支持',
    permissions: ['alerts:read', 'tickets:read', 'knowledge:read'],
    isSystemRole: true,
    createdAt: new Date(),
    updatedAt: new Date()
  }
]);

// 插入默认管理员用户
db.users.insertOne({
  _id: ObjectId(),
  username: 'admin',
  email: 'admin@example.com',
  // 密码: admin123 (需要在应用中进行哈希处理)
  password: '$2a$10$rLs7lX8GRHyQqxLbgpVjOeLnQl7X8GRHyQqxLbgpVjOeLnQl7X8G',
  department: 'IT',
  roles: ['admin'],
  isActive: true,
  createdAt: new Date(),
  updatedAt: new Date()
});

print('MongoDB 初始化完成');
EOF
    
    log_success "MongoDB 初始化脚本已创建"
}

# 创建备份脚本
create_backup_script() {
    log_info "创建数据备份脚本..."
    
    cat > ./scripts/backup.sh << 'EOF'
#!/bin/bash

# 数据备份脚本
BACKUP_DIR="./scripts/backup"
DATE=$(date +%Y%m%d_%H%M%S)

echo "开始数据备份..."

# 创建备份目录
mkdir -p ${BACKUP_DIR}/${DATE}

# 备份 MongoDB
echo "备份 MongoDB..."
docker exec devops-mongodb mongodump --out /tmp/backup
docker cp devops-mongodb:/tmp/backup ${BACKUP_DIR}/${DATE}/mongodb

# 备份 Prometheus 数据
echo "备份 Prometheus 数据..."
docker cp devops-prometheus:/prometheus ${BACKUP_DIR}/${DATE}/prometheus

# 压缩备份
echo "压缩备份文件..."
cd ${BACKUP_DIR}
tar -czf ${DATE}.tar.gz ${DATE}
rm -rf ${DATE}

# 清理旧备份（保留最近7天）
find ${BACKUP_DIR} -name "*.tar.gz" -mtime +7 -delete

echo "备份完成: ${BACKUP_DIR}/${DATE}.tar.gz"
EOF
    
    chmod +x ./scripts/backup.sh
    log_success "备份脚本已创建"
}

# 构建镜像
build_images() {
    log_info "构建 Docker 镜像..."
    
    # 构建后端镜像
    log_info "构建后端镜像..."
    docker-compose build backend
    
    # 构建前端镜像
    log_info "构建前端镜像..."
    docker-compose build frontend
    
    log_success "Docker 镜像构建完成"
}

# 启动服务
start_services() {
    log_info "启动服务..."
    
    # 启动基础服务
    log_info "启动数据库和监控服务..."
    docker-compose up -d mongodb redis prometheus alertmanager grafana node-exporter
    
    # 等待数据库启动
    log_info "等待数据库启动..."
    sleep 10
    
    # 启动应用服务
    log_info "启动应用服务..."
    docker-compose up -d backend frontend
    
    log_success "所有服务已启动"
}

# 验证服务状态
verify_services() {
    log_info "验证服务状态..."
    
    # 等待服务完全启动
    sleep 15
    
    services=(
        "http://localhost:8000/health:后端服务"
        "http://localhost:3000:前端服务"
        "http://localhost:9090:Prometheus"
        "http://localhost:9093:Alertmanager"
        "http://localhost:3001:Grafana"
    )
    
    for service in "${services[@]}"; do
        url=$(echo $service | cut -d: -f1-2)
        name=$(echo $service | cut -d: -f3)
        
        if curl -f -s $url > /dev/null; then
            log_success "$name 正常运行 ($url)"
        else
            log_error "$name 启动失败 ($url)"
        fi
    done
}

# 显示访问信息
show_access_info() {
    echo ""
    echo "🎉 DevOps SmartBot 启动完成！"
    echo "=================================="
    echo ""
    echo "📱 前端应用:        http://localhost:3000"
    echo "🔧 后端 API:        http://localhost:8000"
    echo "📊 Prometheus:      http://localhost:9090"
    echo "🚨 Alertmanager:    http://localhost:9093"
    echo "📈 Grafana:         http://localhost:3001"
    echo ""
    echo "🔐 默认登录信息:"
    echo "   用户名: admin"
    echo "   密码:   admin123"
    echo ""
    echo "📋 常用命令:"
    echo "   查看日志: docker-compose logs -f [service]"
    echo "   重启服务: docker-compose restart [service]"
    echo "   停止服务: docker-compose down"
    echo "   数据备份: ./scripts/backup.sh"
    echo ""
}

# 主函数
main() {
    echo ""
    log_info "开始 DevOps SmartBot 项目初始化..."
    echo ""
    
    check_requirements
    create_env_files
    create_directories
    create_mongo_init
    create_backup_script
    
    # 询问是否构建并启动
    read -p "是否立即构建并启动服务？(y/n) " -n 1 -r
    echo ""
    
    if [[ $REPLY =~ ^[Yy]$ ]]; then
        build_images
        start_services
        verify_services
        show_access_info
    else
        log_info "项目初始化完成。使用以下命令启动服务:"
        echo "docker-compose up -d"
    fi
}

# 错误处理
trap 'log_error "脚本执行失败"; exit 1' ERR

# 执行主函数
main "$@"